home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 June / CHIP Haziran 2001.iso / prog / haziran / 19 / setup.exe / data.z / windrvr.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  2001-04-11  |  35.2 KB  |  1,025 lines
  1. {
  2.   W i n D r i v e r    v 5 . 0 0
  3.   ==============================
  4.  
  5.   Header file for Windows 95/98/ME/NT/NTE/NT2000.
  6.   This file may not be distributed, it is only for evaluation & development purposes.
  7.  
  8.   Web site: http://www.jungo.com/windrv
  9.   Email:    support@jungo.com
  10.  
  11.   (C) Jungo 2001
  12. }
  13.  
  14. unit WinDrvr;
  15. interface
  16. uses
  17.   Windows, Dialogs, SysUtils;
  18.  
  19. const
  20.   WD_VER = 500;
  21.   WD_VER_STR = 'WinDriver V5.00 Jungo (c) 2001';
  22.  
  23.   CMD_NONE = 0;          { No command }
  24.   CMD_END = 1;        { End command }
  25.  
  26.   RP_BYTE = 10;       { Read port byte }
  27.   RP_WORD = 11;       { Read port word }
  28.   RP_DWORD = 12;      { Read port dword }
  29.   WP_BYTE = 13;       { Write port byte }
  30.   WP_WORD = 14;       { Write port word }
  31.   WP_DWORD = 15;      { Write port dword }
  32.  
  33.   RP_SBYTE = 20;      { Read port string byte }
  34.   RP_SWORD = 21;      { Read port string word }
  35.   RP_SDWORD = 22;     { Read port string dword }
  36.   WP_SBYTE = 23;      { Write port string byte }
  37.   WP_SWORD = 24;      { Write port string word }
  38.   WP_SDWORD = 25;     { Write port string dword }
  39.  
  40.   RM_BYTE = 30;       { Read memory byte }
  41.   RM_WORD = 31;       { Read memory word }
  42.   RM_DWORD = 32;      { Read memory dword }
  43.   WM_BYTE = 33;       { Write memory byte }
  44.   WM_WORD = 34;       { Write memory word }
  45.   WM_DWORD = 35;      { Write memory dword }
  46.  
  47.   RM_SBYTE = 40;      { Read memory string byte }
  48.   RM_SWORD = 41;      { Read memory string word }
  49.   RM_SDWORD = 42;     { Read memory string dword }
  50.   WM_SBYTE = 43;      { Write memory string byte }
  51.   WM_SWORD = 44;      { Write memory string word }
  52.   WM_SDWORD = 45;     { Write memory string dword }
  53.  
  54.  
  55.   WD_DMA_PAGES = 256;
  56.  
  57.   DMA_KERNEL_BUFFER_ALLOC = 1; { the system allocates a contiguous buffer }
  58.                                { the user doesnt need to supply linear_address }
  59.   DMA_KBUF_BELOW_16M = 2;      { if DMA_KERNEL_BUFFER_ALLOC if used, }
  60.                                { this will make sure it is under 16M }
  61.   DMA_LARGE_BUFFER   = 4;      { if DMA_LARGE_BUFFER if used, }
  62.                                { the maximum number of pages are dwPages, and not }
  63.                                { WD_DMA_PAGES. if you lock a user buffer (not a kernel }
  64.                                { allocated buffer) that is larger than 1MB, then use this }
  65.                                { option, and allocate memory for pages. }
  66.  
  67. type
  68.  
  69.   PVOID = Pointer;
  70.   HANDLE = THandle;
  71.  
  72.   WD_DMA_PAGE = record
  73.     pPhysicalAddr: PVOID; { physical address of page }
  74.     dwBytes: DWORD { size of page }
  75.   end;
  76.  
  77.   WD_DMA = record
  78.     hDMA: DWORD; { handle of DMA buffer }
  79.     pUserAddr: PVOID; { beginning of buffer }
  80.     dwBytes: DWORD; { size of buffer }
  81.     dwOptions: DWORD; { allocation options: }
  82.     dwPages: DWORD; { number of pages in buffer }
  83.     Page: array [0 .. WD_DMA_PAGES - 1] of WD_DMA_PAGE
  84.   end;
  85.  
  86.   SWD_TRANSFER = record { replaces WD_TRANSFER structure to avoid conflict }
  87.                         { with WD_Transfer() function }
  88.     cmdTrans: DWORD; { Transfer command SWD_TRANSFER_CMD  }
  89.     dwPort: DWORD;   { IO port for transfer or user memory address }
  90.     dwBytes: DWORD;  { For string transfer }
  91.     fAutoInc: DWORD; { Transfer from one port/address or }
  92.                      { use incremental range of addresses   }
  93.     dwOptions: DWORD; { Must be 0 }
  94.     case Integer of
  95.       0: (AByte: BYTE); { Byte transfer }
  96.       1: (AWord: WORD); { Word transfer }
  97.       2: (ADword: DWORD); { Dword transfer }
  98.       3: (pBuffer: PVOID) { String transfer }
  99.   end;
  100.     PWD_TRANSFER = ^ SWD_TRANSFER;
  101.  
  102. const
  103.   INTERRUPT_LEVEL_SENSITIVE = 1;
  104.   INTERRUPT_CMD_COPY = 2;
  105.  
  106. type
  107.   WD_KERNEL_PLUGIN_CALL = record
  108.     hKernelPlugIn: DWORD;
  109.     dwMessage:  DWORD;
  110.     pData: PVOID;
  111.     dwResult: DWORD
  112.   end;
  113.  
  114.   WD_INTERRUPT = record
  115.     hInterrupt:  DWORD; { handle of interrupt }
  116.     dwOptions: DWORD; { interrupt options: INTERRUPT_CMD_COPY }
  117.     Cmd:  PWD_TRANSFER; { commands to do on interrupt }
  118.     dwCmds: DWORD; { number of commands for WD_IntEnable() }
  119.     kpCall: WD_KERNEL_PLUGIN_CALL; { kernel plugin call }
  120.     fEnableOk:  DWORD; { did WD_IntEnable() succeed }
  121.                        { For WD_IntWait() and WD_IntCount() }
  122.     dwCounter:  DWORD; { number of interrupts received }
  123.     dwLost: DWORD; { number of interrupts not yet dealt with }
  124.     fStopped: DWORD { was interrupt disabled during wait }
  125.   end;
  126.  
  127.   SWD_VERSION = record  { replaces WD_VERSION structure to avoid conflict }
  128.                         {   with WD_Version() function }
  129.     dwVer: DWORD;
  130.     cVer: array [0 .. 100-1] of CHAR { needs testing if pascal string is compatible }
  131.   end;
  132.  
  133. const
  134.   LICENSE_DEMO=$1;   LICENSE_WD=$4;    LICENSE_KD=$400000;
  135.   LICENSE_IO  =$8;   LICENSE_MEM =$10; LICENSE_INT =$20;
  136.   LICENSE_PCI =$40;  LICENSE_DMA =$80; LICENSE_NT  =$100;
  137.   LICENSE_95  =$200; LICENSE_ISAPNP=$400;  LICENSE_PCMCIA=$800;
  138.   LICENSE_PCI_DUMP=$1000; LICENSE_MSG_GEN=$2000; LICENSE_MSG_EDU=$4000;
  139.   LICENSE_MSG_INT=$8000;  LICENSE_KER_PLUG=$10000;
  140.  
  141.   LICENSE2_CPCI=$1;
  142.  
  143. type
  144.   SWD_LICENSE = record  { replaces WD_LICENSE structure to avoid conflict }
  145.                         { with WD_License() function }
  146.   cLicense: array [0 .. 100-1] of CHAR; { buffer with license string to }
  147.                           { put. If empty string then get }
  148.                           { current license setting into  }
  149.                           { dwLicense }
  150.   dwLicense:  DWORD;    { Returns license settings: }
  151.   dwLicense2: DWORD     {   LICENSE_DEMO, LICENSE_WD etc... }
  152.                         { If put license was unsuccessful }
  153.                         { (i.e. invalid license) then dwLicense }
  154.                         { will return 0. }
  155.   end;
  156.  
  157. const
  158.   ITEM_NONE=0; ITEM_INTERRUPT=1; ITEM_MEMORY=2; ITEM_IO=3; ITEM_BUS=5;
  159.  
  160. type
  161.   WD_ITEM_MEMORY = record
  162.     dwPhysicalAddr: DWORD; { Physical address on card }
  163.     dwMBytes: DWORD; { Address range }
  164.     dwTransAddr: DWORD; { Returns the address to pass }
  165.                         { on to transfer commands }
  166.     dwUserDirectAddr: DWORD; { Returns the address for}
  167.                              { direct user read/write }
  168.     dwCpuPhysicalAddr: DWORD { returns the CPU physical address of card }
  169.   end;
  170.  
  171.   WD_ITEM_IO = record
  172.     dwAddr: DWORD; { Begining of IO address }
  173.     dwBytes: DWORD { IO range }
  174.   end;
  175.  
  176.   WD_ITEM_INTERRUPT = record
  177.     dwInterrupt: DWORD; { Number of interrupt to }
  178.                         { install }
  179.     dwOptions: DWORD; { Interrupt options: }
  180.                       { INTERRUPT_LEVEL_SENSITIVE   }
  181.     hInterrupt: DWORD { Returns the handle of the }
  182.                       { interrupt installed }
  183.   end;
  184.  
  185.   WD_BUS = record
  186.     dwBusType: DWORD;    { Bus type: ISA, EISA, PCI, PCMCIA }
  187.     dwBusNum: DWORD;     { Bus number }
  188.     dwSlotFunc: DWORD    { Slot number on Bus }
  189.   end;
  190.  
  191.   WD_ITEM_VALUE = record
  192.     dw1: DWORD;
  193.     dw2: DWORD;
  194.     dw3: DWORD;
  195.     dw4: DWORD;
  196.     dw5: DWORD
  197.   end;
  198.  
  199.   WD_ITEMS = record
  200.     Item: DWORD { ITEM_TYPE };
  201.     fNotSharable: DWORD;
  202.     case Integer of
  203.       0 { ITEM_MEMORY }:
  204.         (
  205.           Memory: WD_ITEM_MEMORY
  206.         );
  207.       1 { ITEM_IO }:
  208.         (
  209.           IO: WD_ITEM_IO
  210.         );
  211.       2 { ITEM_INTERRUPT }:
  212.         (
  213.           Interrupt: WD_ITEM_INTERRUPT
  214.         );
  215.       3 { ITEM_BUS }:
  216.         (
  217.           Bus: WD_BUS
  218.         );
  219.       4 { ITEM_VALUE }:
  220.         (
  221.           Value: WD_ITEM_VALUE
  222.         )
  223.     end;
  224.  
  225.   PWD_ITEMS = ^WD_ITEMS;
  226.  
  227. const
  228.   WD_CARD_ITEMS = 20;
  229. type
  230.   WD_CARD = record
  231.     dwItems: DWORD;
  232.     Item: array [0 .. WD_CARD_ITEMS - 1] of WD_ITEMS
  233.   end;
  234.  
  235.   PWD_CARD = ^WD_CARD;
  236.  
  237.   WD_CARD_REGISTER = record
  238.     Card: WD_CARD; { card to register }
  239.     fCheckLockOnly: DWORD   ; { only check if card is lockable, return hCard=1 if OK }
  240.     hCard: DWORD; { handle of card }
  241.     dwOptions: DWORD; { should be zero }
  242.     cName:  array[0 .. 32-1] of CHAR; { name of card }
  243.     cDescription: array [0 .. 100-1] of CHAR { description }
  244.   end;
  245.  
  246. const
  247.   WD_PCI_CARDS = 30;
  248.  
  249. type
  250.   WD_PCI_SLOT = record
  251.     dwBus: DWORD;
  252.     dwSlot: DWORD;
  253.     dwFunction: DWORD
  254.   end;
  255.  
  256.   PWD_PCI_SLOT = ^WD_PCI_SLOT;
  257.  
  258.   WD_PCI_ID = record
  259.     dwVendorId: DWORD;
  260.     dwDeviceId: DWORD
  261.   end;
  262.  
  263.   WD_PCI_SCAN_CARDS = record
  264.     searchId: WD_PCI_ID; { if dwVendorId = 0, scan all vendor Ids }
  265.                          { if dwDeviceId = 0, scan all device Ids }
  266.     dwCards: DWORD; { Number of cards found }
  267.     cardId: array [0 .. WD_PCI_CARDS - 1] of WD_PCI_ID;
  268.                      { VendorID & DeviceID of cards found  }
  269.     cardSlot: array [0 .. WD_PCI_CARDS - 1] of WD_PCI_SLOT
  270.                      { PCI slot info of cards found }
  271.   end;
  272.  
  273.   WD_PCI_CARD_INFO = record
  274.     pciSlot: WD_PCI_SLOT; { PCI slot }
  275.     Card: WD_CARD { Get card parameters for PCI slot }
  276.   end;
  277.  
  278. const
  279.   PCI_ACCESS_OK=0; PCI_ACCESS_ERROR=1; PCI_BAD_BUS=2; PCI_BAD_SLOT=3;
  280.  
  281. type
  282.   WD_PCI_CONFIG_DUMP = record
  283.     pciSlot: WD_PCI_SLOT; { PCI bus, slot and function number }
  284.     pBuffer: PVOID; { buffer for read/write }
  285.     dwOffset: DWORD; { offset in pci configuration space  }
  286.                      { to read/write from }
  287.     dwBytes: DWORD; { bytes to read/write from/to buffer  }
  288.                     { returns the # of bytes read/written }
  289.     fIsRead: DWORD; { if 1 then read pci config, 0 write  }
  290.                     { pci config }
  291.     dwResult: DWORD { PCI_ACCESS_RESULT }
  292.   end;
  293.  
  294. const
  295.   WD_ISAPNP_CARDS = 16 ;
  296.  
  297. const
  298.   WD_ISAPNP_COMPATIBLE_IDS = 10 ;
  299.  
  300. const
  301.   WD_ISAPNP_COMP_ID_LENGTH = 7 ; { ISA compressed ID is 7 chars long }
  302.  
  303. const
  304.   WD_ISAPNP_ANSI_LENGTH = 32 ; { ISA ANSI ID is limited to 32 chars long }
  305.  
  306. type
  307.   WD_ISAPNP_COMP_ID = array[0 .. WD_ISAPNP_COMP_ID_LENGTH] of CHAR;
  308.   WD_ISAPNP_ANSI = array[0 .. WD_ISAPNP_ANSI_LENGTH+3] of CHAR; { add 3 bytes for DWORD alignment }
  309.  
  310.   WD_ISAPNP_CARD_ID = record
  311.     cVendor: WD_ISAPNP_COMP_ID;  { Vendor ID }
  312.     dwSerial: DWORD { Serial number of card }
  313.   end;
  314.  
  315.   WD_ISAPNP_CARD = record
  316.     cardId:  WD_ISAPNP_CARD_ID; { VendorID & serial number of cards found }
  317.     dcLogicalDevices:  DWORD;   { Logical devices on the card }
  318.     bPnPVersionMajor:  BYTE; { ISA PnP version Major }
  319.     bPnPVersionMinor:  BYTE; { ISA PnP version Minor }
  320.     bVendorVersionMajor:  BYTE; { Vendor version Major }
  321.     bVendorVersionMinor:  BYTE; { Vendor version Minor }
  322.     cIdent:  WD_ISAPNP_ANSI ;{ Device identifier }
  323.   end;
  324.  
  325.   WD_ISAPNP_SCAN_CARDS = record
  326.     searchId: WD_ISAPNP_CARD_ID; { if searchId.cVendor[0]==0 - scan all vendor IDs
  327.                                    if searchId.dwSerial==0 - scan all serial numbers }
  328.     dwCards:  DWORD; { number of cards found }
  329.     Card: array[0 .. WD_ISAPNP_CARDS-1] of WD_ISAPNP_CARD  { cards found }
  330.   end;
  331.  
  332.  
  333.   WD_ISAPNP_CARD_INFO = record
  334.     cardId:  WD_ISAPNP_CARD_ID; { VendorID and serial number of card }
  335.     dwLogicalDevice: DWORD; { logical device in card }
  336.     cLogicalDeviceId:  WD_ISAPNP_COMP_ID; { logical device ID }
  337.     dwCompatibleDevices: DWORD; { number of compatible device IDs }
  338.     CompatibleDevice: array[0 .. WD_ISAPNP_COMPATIBLE_IDS-1] of WD_ISAPNP_COMP_ID; { Compatible device IDs }
  339.     cIdent: WD_ISAPNP_ANSI;  { Device identifier }
  340.     Card: WD_CARD  { get card parameters for the ISA PnP card }
  341.   end;
  342.  
  343. type
  344.   WD_ISAPNP_CONFIG_DUMP = record
  345.     cardId: WD_ISAPNP_CARD_ID;  { VendorID and serial number of card }
  346.     dwOffset: DWORD; { offset in ISA PnP configuration space to read/write from }
  347.     fIsRead: DWORD; { if 1 then read ISA PnP config, 0 write ISA PnP config }
  348.     bData:  BYTE;  { result data of byte read/write }
  349.     dwResult: DWORD { ISAPNP_ACCESS_RESULT }
  350.   end;
  351.  
  352. const
  353.   ISAPNP_ACCESS_OK = 0; ISAPNP_ACCESS_ERROR = 1; ISAPNP_BAD_ID = 2;
  354.  
  355. { PCMCIA Card Services }
  356.  
  357. const
  358.     WD_PCMCIA_CARDS = 8;
  359.  
  360. const
  361.     WD_PCMCIA_VERSION_LEN = 4;
  362.  
  363. const
  364.     WD_PCMCIA_MANUFACTURER_LEN = 48;
  365.  
  366. const
  367.     WD_PCMCIA_PRODUCTNAME_LEN = 48;
  368.  
  369. const
  370.     WD_PCMCIA_MAX_SOCKET = 2;
  371.  
  372. const
  373.     WD_PCMCIA_MAX_FUNCTION = 2;
  374.  
  375. type
  376.   WD_PCMCIA_SLOT = record
  377.     uSocket: BYTE;      {Specifies the socket number (first socket is 0)}
  378.     uFunction: BYTE;    {Specifies the function number (first function is 0)}
  379.     uPadding0: BYTE;    {2 bytes padding so structure will be 4 bytes aligned}
  380.     uPadding1: BYTE
  381.    end;
  382.  
  383.   WD_PCMCIA_ID = record
  384.     dwManufacturerId: DWORD; {card manufacturer}
  385.     dwCardId: DWORD          {card type and model}
  386.   end;
  387.  
  388.   WD_PCMCIA_SCAN_CARDS = record
  389.    searchId: WD_PCMCIA_ID;  {device ID to search for}
  390.    dwCards: DWORD;          {number of cards found}
  391.    cardId: array [0..WD_PCMCIA_CARDS-1] of WD_PCMCIA_ID;      {device IDs of cards found}
  392.    cardSlot: array [0..WD_PCMCIA_CARDS-1] of WD_PCMCIA_SLOT  {pcmcia slot info of cards found}
  393.   end;
  394.  
  395.   WD_PCMCIA_CARD_INFO = record
  396.     pcmciaSlot: WD_PCMCIA_SLOT; {pcmcia slot}
  397.     Card: WD_CARD;              {get card parameters for pcmcia slot}
  398.     cVersion: array [0..WD_PCMCIA_VERSION_LEN-1] of CHAR;
  399.     cManufacturer: array [0..WD_PCMCIA_MANUFACTURER_LEN-1] of CHAR;
  400.     cProductName: array [0..WD_PCMCIA_PRODUCTNAME_LEN-1] of CHAR;
  401.     dwManufacturerId: DWORD;   {card manufacturer}
  402.     dwCardId: DWORD;           {card type and model}
  403.     dwFuncId: DWORD            {card function code}
  404.   end;
  405.  
  406.   WD_PCMCIA_CONFIG_DUMP = record
  407.     pcmciaSlot: WD_PCMCIA_SLOT;
  408.     pBuffer: PVOID;    {buffer for read/write}
  409.     dwOffset: DWORD;   {offset in pcmcia configuration space to}
  410.                    {read/write from}
  411.     dwBytes: DWORD;    {bytes to read/write from/to buffer}
  412.                        {returns the number of bytes read/wrote}
  413.     fIsRead: DWORD;    {if 1 then read pci config, 0 write pci config}
  414.     dwResult: DWORD   {PCMCIA_ACCESS_RESULT}
  415.    end;
  416.  
  417. const
  418.   SLEEP_NON_BUSY = 1;
  419.  
  420. type
  421.   SWD_SLEEP = record    { replaces WD_SLEEP structure to avoid conflict }
  422.                         { with WD_Sleep() function }
  423.     dwMicroSeconds: DWORD; { Sleep time in Micro Seconds (1/1,000,000 Second) }
  424.     dwOptions: DWORD  { can be:
  425.                         SLEEP_NON_BUSY this is accurate only for times above 10000 uSec }
  426.   end;
  427.  
  428. const
  429.   D_OFF = 0; D_ERROR=1; D_WARN=2; D_INFO=3; D_TRACE=4;
  430.  
  431. const
  432.   S_ALL =$ffffffff;
  433.   S_IO  =$8; S_MEM =$10; S_INT=$20; S_PCI=$40; S_DMA=$80; S_MISC=$100; S_LICENSE=$200;
  434.   S_ISAPNP=$400; S_PCMCIA=$800; S_KER_PLUG=$10000; S_CARD_REG=$2000;
  435.  
  436. const
  437.   DEBUG_STATUS = 1;
  438.   DEBUG_SET_FILTER = 2;
  439.   DEBUG_SET_BUFFER = 3;
  440.   DEBUG_CLEAR_BUFFER = 4;
  441.   DEBUG_DUMP_SEC_ON = 5;
  442.   DEBUG_DUMP_SEC_OFF = 6;
  443.  
  444. const
  445.     METHOD_BUFFERED   = 0;
  446.     METHOD_IN_DIRECT  = 1;
  447.     METHOD_OUT_DIRECT = 2;
  448.     METHOD_NEITHER    = 3;
  449.  
  450. const
  451.     FILE_ANY_ACCESS   = $0;
  452.     FILE_READ_ACCESS  = $1;    { file & pipe }
  453.     FILE_WRITE_ACCESS = $2;    { file & pipe }
  454.  
  455.  
  456. type
  457.  
  458.   SWD_DEBUG = record    { replaces WD_DEBUG structure to avoid conflict }
  459.                         { with WD_Debug() function }
  460.     dwCmd: DWORD;  { DEBUG_COMMAND: DEBUG_STATUS, DEBUG_SET_FILTER, DEBUG_SET_BUFFER, DEBUG_CLEAR_BUFFER
  461.                      used for DEBUG_SET_FILTER }
  462.     dwLevel: DWORD;   { DEBUG_LEVEL: D_ERROR, D_WARN..., or D_OFF to turn debugging off }
  463.     dwSection: DWORD; { DEBUG_SECTION: for all sections in driver: S_ALL
  464.                         for partial sections: S_IO, S_MEM... }
  465.     dwLevelMessageBox: DWORD; { DEBUG_LEVEL to print in a message box
  466.                                 used for DEBUG_SET_BUFFER }
  467.     dwBufferSize: DWORD { size of buffer in kernel }
  468.   end;
  469.  
  470.   WD_DEBUG_DUMP = record
  471.     pcBuffer: PCHAR; { buffer to receive debug messages }
  472.     dwSize: DWORD { size of buffer in bytes }
  473.   end;
  474.  
  475.   WD_KERNEL_PLUGIN = record
  476.     hKernelPlugIn: DWORD;
  477.     pcDriverName: PCHAR;
  478.     pcDriverPath: PCHAR; { if NULL the driver will be searched in the windows system directory  }
  479.     pOpenData: PVOID
  480.   end;
  481.  
  482. { taken from usbdi.h }
  483. type USBD_PIPE_TYPE = DWORD;
  484. const
  485.     UsbdPipeTypeControl     = 0;
  486.     UsbdPipeTypeIsochronous = 1;
  487.     UsbdPipeTypeBulk        = 2;
  488.     UsbdPipeTypeInterrupt   = 3;
  489.  
  490. var { Pseudo constants }
  491.     IOCTL_WD_USB_RESET_PIPE        : INTEGER;
  492.     IOCTL_WD_USB_RESET_DEVICE      : INTEGER;
  493.     IOCTL_WD_USB_SCAN_DEVICES      : INTEGER;
  494.     IOCTL_WD_USB_SCAN_DEVICES_V432 : INTEGER;
  495.     IOCTL_WD_USB_TRANSFER          : INTEGER;
  496.     IOCTL_WD_USB_DEVICE_REGISTER   : INTEGER;
  497.     IOCTL_WD_USB_DEVICE_UNREGISTER : INTEGER;
  498.     IOCTL_WD_USB_GET_CONFIGURATION : INTEGER;
  499.  
  500. const
  501.     WD_USB_MAX_PIPE_NUMBER   = 32;
  502.     WD_USB_MAX_ENDPOINTS     = 32;
  503.     WD_USB_MAX_INTERFACES    = 30;
  504.     WD_USB_MAX_DEVICE_NUMBER = 127;
  505.  
  506. type
  507.     WD_USB_ID = record
  508.         dwVendorId : DWORD;
  509.         dwProductId : DWORD;
  510. end;
  511.  
  512.     PWD_USB_ID = ^WD_USB_ID;
  513.  
  514. type USB_DIR = DWORD;
  515. const
  516.     UsbDirIn    = 1;
  517.     UsbDirOut   = 2;
  518.     UsbDirInOot = 3;
  519.  
  520. type
  521.     WD_USB_PIPE_INFO = record
  522.         dwNumber : DWORD;  {Pipe 0 is the default pipe}
  523.     MaximumPacketSize : DWORD;
  524.     PipeType : DWORD;  { USBD_PIPE_TYPE }
  525.         direction : DWORD; {USB_DIR
  526.                             Isochronous, Bulk, Interrupt are either USB_DIR_IN
  527.                             or USB_DIR_OUT Control are USB_DIR_IN_OUT}
  528.         dwInterval : DWORD {interval in ms relevant to Interrupt pipes}
  529. end;
  530.  
  531.     PWD_USB_PIPE_INFO = ^WD_USB_PIPE_INFO;
  532.  
  533. type
  534.     WD_USB_CONFIG_DESC = record
  535.         dwNumInterfaces : DWORD;
  536.         dwValue : DWORD;
  537.         dwAttributes : DWORD;
  538.         MaxPower : DWORD;
  539. end;
  540.  
  541.     PWD_USB_CONFIG_DESC = ^WD_USB_CONFIG_DESC;
  542.  
  543. type
  544.     WD_USB_INTERFACE_DESC = record
  545.         dwNumber : DWORD;
  546.         dwAlternateSetting : DWORD;
  547.         dwNumEndpoints : DWORD;
  548.         dwClass : DWORD;
  549.         dwSubClass : DWORD;
  550.         dwProtocol : DWORD;
  551.         dwIndex : DWORD;
  552. end;
  553.  
  554.     PWD_USB_INTERFACE_DESC = ^WD_USB_INTERFACE_DESC;
  555.  
  556. type
  557.     WD_USB_ENDPOINT_DESC = record
  558.         dwEndpointAddress : DWORD;
  559.         dwAttributes : DWORD;
  560.         dwMaxPacketSize : DWORD;
  561.         dwInterval : DWORD;
  562. end;
  563.  
  564.     PWD_USB_ENDPOINT_DESC = ^WD_USB_ENDPOINT_DESC;
  565.  
  566. type
  567.     WD_USB_INTERFACE = record
  568.         InterfaceDesc : WD_USB_INTERFACE_DESC;
  569.         Endpoints : array[0..WD_USB_MAX_ENDPOINTS-1] of WD_USB_ENDPOINT_DESC;
  570. end;
  571.  
  572.     PWD_USB_INTERFACE = ^WD_USB_INTERFACE;
  573.  
  574. type
  575.     WD_USB_CONFIGURATION = record
  576.         uniqueId : DWORD;
  577.         dwConfigurationIndex : DWORD;
  578.         configuration : WD_USB_CONFIG_DESC;
  579.         dwInterfaceAlternatives : DWORD;
  580.         UsbInterface : array[0..WD_USB_MAX_INTERFACES-1] of WD_USB_INTERFACE;
  581. end;
  582.  
  583.     PWD_USB_CONFIGURATION = ^PWD_USB_CONFIGURATION;
  584.  
  585. type
  586.     WD_USB_HUB_GENERAL_INFO = record
  587.         fBusPowered : DWORD;
  588.         dwPorts : DWORD;              {number of ports on this hub}
  589.         dwCharacteristics : DWORD;    {Hub Charateristics}
  590.         dwPowerOnToPowerGood : DWORD; {port power on till power good in 2ms}
  591.         dwHubControlCurrent : DWORD;  {max current in mA}
  592. end;
  593.  
  594.     PWD_USB_HUB_GENERAL_INFO = ^WD_USB_HUB_GENERAL_INFO;
  595.  
  596. type
  597.     WD_USB_DEVICE_GENERAL_INFO = record
  598.        deviceId : WD_USB_ID;
  599.        dwHubNum : DWORD;
  600.        dwPortNum : DWORD;
  601.        fHub : DWORD;
  602.        fFullSpeed : DWORD;
  603.        dwConfigurationsNum : DWORD;
  604.        deviceAddress : DWORD;
  605.        hubInfo : WD_USB_HUB_GENERAL_INFO;
  606. end;
  607.  
  608.     PWD_USB_DEVICE_GENERAL_INFO = ^WD_USB_DEVICE_GENERAL_INFO;
  609.  
  610. type
  611.     WD_USB_DEVICE_INFO = record
  612.     dwPipes : DWORD;
  613.     Pipe : array[0..WD_USB_MAX_PIPE_NUMBER-1] of WD_USB_PIPE_INFO;
  614. end;
  615.  
  616.     PWD_USB_DEVICE_INFO = ^WD_USB_DEVICE_INFO;
  617.  
  618. { IOCTL Structures }
  619. type
  620.     WD_USB_SCAN_DEVICES = record
  621.         searchId : WD_USB_ID;  {if dwVendorId==0 - scan all vendor IDs
  622.                                 if dwProductId==0 - scan all product IDs}
  623.         dwDevices : DWORD;
  624.         uniqueId : array[0..WD_USB_MAX_DEVICE_NUMBER-1] of DWORD; { a unique id to identify the device}
  625.         deviceGeneralInfo : array[0..WD_USB_MAX_DEVICE_NUMBER] of WD_USB_DEVICE_GENERAL_INFO;
  626. end;
  627.  
  628.     PWD_USB_SCAN_DEVICES = ^WD_USB_SCAN_DEVICES;
  629.  
  630. { USB TRANSFER options }
  631. const
  632.     USB_TRANSFER_HALT = 1;
  633.  
  634. type
  635.     WD_USB_TRANSFER = record
  636.     hDevice : DWORD;    {handle of USB device to read from or write to}
  637.     dwPipe : DWORD;     {pipe number on device}
  638.         fRead : BOOLEAN;
  639.     dwOptions : DWORD;  {USB_TRANSFER options:
  640.                              USB_TRANSFER_HALT halts the pervious transfer on the pipe}
  641.         pBuffer : PVOID;      {pointer to buffer to read/write}
  642.         dwBytes : DWORD;
  643.         dwTimeout : DWORD;    {timeout for the transfer in milli-seconds. 0==>no timeout.}
  644.     dwBytesTransfered : DWORD; {returns the number of bytes actually read/written}
  645.         SetupPacket : array[0..7] of BYTE;    {setup packet for control pipe transfer}
  646.         fOK : DWORD;
  647. end;
  648.  
  649.     PWD_USB_TRANSFER = ^WD_USB_TRANSFER;
  650.  
  651. type
  652.     WD_USB_DEVICE_REGISTER = record
  653.         uniqueId : DWORD;                   {the device unique ID}
  654.         dwConfigurationIndex : DWORD;       {the index of the configuration to register}
  655.         dwInterfaceNum : DWORD;             {interface to register}
  656.         dwInterfaceAlternate : DWORD;
  657.     hDevice : DWORD;                    {handle of device}
  658.     Device : WD_USB_DEVICE_INFO;        {description of the device}
  659.         dwOptions : DWORD;                  {should be zero}
  660.         cName : array[0..31] of CHAR ;      {name of card}
  661.         cDescription: array[0..99] of CHAR; {description}
  662. end;
  663.  
  664.     PWD_USB_DEVICE_REGISTER = ^WD_USB_DEVICE_REGISTER;
  665.  
  666. type
  667.     WD_USB_RESET_PIPE = record
  668.         hDevice : DWORD;
  669.     dwPipe : DWORD;
  670. end;
  671.  
  672.     PWD_USB_RESET_PIPE = ^WD_USB_RESET_PIPE;
  673.  
  674. function WD_Open : HANDLE;
  675. procedure WD_Close(hWD: HANDLE);
  676. procedure WD_Debug(hWD: HANDLE;var  Debug: SWD_DEBUG);
  677. procedure WD_DebugDump(hWD: HANDLE; var DebugDump: WD_DEBUG_DUMP);
  678. procedure WD_Transfer(hWD: HANDLE; var Transfer: SWD_TRANSFER);
  679. procedure WD_MultiTransfer(hWD: HANDLE; var TransferArray: array of SWD_TRANSFER);
  680. procedure WD_DMALock(hWD: HANDLE; var Dma: WD_DMA);
  681. procedure WD_DMAUnlock(hWD: HANDLE; var Dma: WD_DMA);
  682. procedure WD_IntEnable(hWD: HANDLE; var TheInterrupt: WD_INTERRUPT);
  683. procedure WD_IntDisable(hWD: HANDLE; var TheInterrupt: WD_INTERRUPT);
  684. procedure WD_IntCount(hWD: HANDLE; var TheInterrupt: WD_INTERRUPT);
  685. procedure WD_IntWait(hWD: HANDLE; var TheInterrupt: WD_INTERRUPT);
  686. procedure WD_IsapnpScanCards(hWD: HANDLE; var IsapnpScanCards: WD_ISAPNP_SCAN_CARDS);
  687. procedure WD_IsapnpGetCardInfo(hWD: HANDLE; var IsapnpGetCardInfo: WD_ISAPNP_CARD_INFO);
  688. procedure WD_IsapnpConfigDump(hWD: HANDLE; var IsapnpConfigDump: WD_ISAPNP_CONFIG_DUMP);
  689. procedure WD_PcmciaScanCards(hWD: HANDLE; var PcmciaScanCards: WD_PCMCIA_SCAN_CARDS);
  690. procedure WD_PcmciaGetCardInfo(hWD: HANDLE; var PcmciaGetCardInfo: WD_PCMCIA_CARD_INFO);
  691. procedure WD_PcmciaConfigDump(hWD: HANDLE; var PcmciaConfigDump: WD_PCMCIA_CONFIG_DUMP);
  692. procedure WD_Sleep(hWD: HANDLE; var Sleep: SWD_SLEEP);
  693. procedure WD_CardRegister(hWD: HANDLE; var Card: WD_CARD_REGISTER);
  694. procedure WD_CardUnregister(hWD: HANDLE; var Card: WD_CARD_REGISTER);
  695. procedure WD_PciScanCards(hWD: HANDLE; var PciScan: WD_PCI_SCAN_CARDS);
  696. procedure WD_PciGetCardInfo(hWD: HANDLE; var PciCard: WD_PCI_CARD_INFO);
  697. procedure WD_Version(hWD: HANDLE; var VerInfo: SWD_VERSION);
  698. procedure WD_License(hWD: HANDLE; var License: SWD_LICENSE);
  699. procedure WD_KernelPlugInOpen(hWD: HANDLE; var KernelPlugInOpen: WD_KERNEL_PLUGIN);
  700. procedure WD_KernelPlugInClose(hWD: HANDLE; var KernelPlugInClose: WD_KERNEL_PLUGIN);
  701. procedure WD_KernelPlugInCall(hWD: HANDLE; var KernelPlugInCall: WD_KERNEL_PLUGIN_CALL);
  702. procedure WD_PciConfigDump(hWD: HANDLE; var PciConfigDump: WD_PCI_CONFIG_DUMP);
  703. procedure WD_UsbScanDevice(h : HANDLE; pDeviceId : PWD_USB_ID);
  704. procedure WD_UsbGetConfiguration(h : HANDLE; pDeviceId : PWD_USB_ID);
  705. procedure WD_UsbDeviceRegister(h : HANDLE; pRegister : PWD_USB_DEVICE_REGISTER);
  706. procedure WD_UsbTransfer(h : HANDLE; pTrans : PWD_USB_TRANSFER);
  707. procedure WD_UsbDeviceUnregister(h : HANDLE; pTrans : PWD_USB_DEVICE_REGISTER);
  708. procedure WD_UsbResetPipe(h : HANDLE; pResetPipe : PWD_USB_RESET_PIPE);
  709. procedure WD_UsbResetDevice(h : HANDLE; hDevice : DWORD);
  710.  
  711. var
  712.   WinDriverGlobalDW: DWORD;
  713.   { Pseudo constants }
  714.   IOCTL_WD_DMA_LOCK: integer;
  715.   IOCTL_WD_DMA_UNLOCK: integer;
  716.   IOCTL_WD_TRANSFER: integer;
  717.   IOCTL_WD_MULTI_TRANSFER: integer;
  718.   IOCTL_WD_PCI_SCAN_CARDS: integer;
  719.   IOCTL_WD_PCI_GET_CARD_INFO: integer;
  720.   IOCTL_WD_VERSION: integer;
  721.   IOCTL_WD_LICENSE: integer;
  722.   IOCTL_WD_PCI_CONFIG_DUMP: integer;
  723.   IOCTL_WD_KERNEL_PLUGIN_OPEN: integer;
  724.   IOCTL_WD_KERNEL_PLUGIN_CLOSE: integer;
  725.   IOCTL_WD_KERNEL_PLUGIN_CALL: integer;
  726.   IOCTL_WD_INT_ENABLE: integer;
  727.   IOCTL_WD_INT_DISABLE: integer;
  728.   IOCTL_WD_INT_COUNT: integer;
  729.   IOCTL_WD_INT_WAIT: integer;
  730.   IOCTL_WD_ISAPNP_SCAN_CARDS: integer;
  731.   IOCTL_WD_ISAPNP_GET_CARD_INFO: integer;
  732.   IOCTL_WD_ISAPNP_CONFIG_DUMP: integer;
  733.   IOCTL_WD_SLEEP: integer;
  734.   IOCTL_WD_DEBUG: integer;
  735.   IOCTL_WD_DEBUG_DUMP: integer;
  736.   IOCTL_WD_CARD_UNREGISTER: integer;
  737.   IOCTL_WD_CARD_REGISTER: integer;
  738.   IOCTL_WD_PCMCIA_SCAN_CARDS: integer;
  739.   IOCTL_WD_PCMCIA_GET_CARD_INFO: integer;
  740.   IOCTL_WD_PCMCIA_CONFIG_DUMP: integer;
  741.  
  742.  
  743. function Get_Ctl_Code(Nr: Integer): Integer;
  744.  
  745. implementation
  746. const
  747.   WD_TYPE = 38200;
  748.  
  749. {This is an implementation of a WinIOCTL macro (CTL_CODE) }
  750. function Get_Ctl_Code(Nr: Integer): Integer;
  751. begin
  752.   Result:= (WD_TYPE shl 16) or (FILE_ANY_ACCESS shl 14) or (Nr shl 2) or
  753.             METHOD_NEITHER
  754. end;
  755.  
  756. function WD_Open: HANDLE;
  757. begin
  758.   WD_Open := CreateFile(PChar('\\.\WINDRVR'), GENERIC_READ,
  759.                           FILE_SHARE_READ or FILE_SHARE_WRITE,
  760.                           nil, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
  761. end;
  762.  
  763. procedure WD_Close(hWD: HANDLE);
  764. begin
  765.   CloseHandle(hWD);
  766. end ;
  767.  
  768. procedure WD_Debug(hWD: HANDLE ;var Debug: SWD_DEBUG);
  769. begin
  770.   DeviceIOControl(hWD, IOCTL_WD_DEBUG, @Debug,
  771.                   SizeOf(SWD_DEBUG), nil, 0, WinDriverGlobalDW, nil)
  772. end;
  773.  
  774. procedure WD_DebugDump(hWD: HANDLE ;var DebugDump: WD_DEBUG_DUMP);
  775. begin
  776.   DeviceIOControl(hWD, IOCTL_WD_DEBUG_DUMP, @DebugDump,
  777.                   SizeOf(WD_DEBUG_DUMP), nil, 0, WinDriverGlobalDW, nil)
  778. end;
  779.  
  780. procedure WD_Transfer(hWD: HANDLE ;var Transfer: SWD_TRANSFER);
  781. begin
  782.   DeviceIOControl(hWD, IOCTL_WD_TRANSFER, @Transfer,
  783.                   SizeOf(SWD_TRANSFER), nil, 0, WinDriverGlobalDW, nil)
  784. end;
  785.  
  786. procedure WD_MultiTransfer(hWD: HANDLE ; var TransferArray: array of SWD_TRANSFER);
  787. begin
  788.   DeviceIOControl(hWD, IOCTL_WD_MULTI_TRANSFER, @TransferArray,
  789.                   SizeOf(SWD_TRANSFER) * (High(TransferArray) + 1), nil,
  790.                   0, WinDriverGlobalDW, nil)
  791. end;
  792.  
  793. procedure WD_DMALock(hWD: HANDLE ;var Dma: WD_DMA);
  794. begin
  795.   DeviceIOControl(hWD, IOCTL_WD_DMA_LOCK, @Dma, SizeOf(WD_DMA), nil, 0,
  796.                   WinDriverGlobalDW, nil)
  797. end;
  798.  
  799. procedure WD_DMAUnlock(hWD: HANDLE ;var Dma: WD_DMA);
  800. begin
  801.   DeviceIOControl(hWD, IOCTL_WD_DMA_UNLOCK, @Dma, SizeOf(WD_DMA), nil,
  802.                   0, WinDriverGlobalDW, nil)
  803. end;
  804.  
  805. procedure WD_IntEnable(hWD: HANDLE ;var TheInterrupt: WD_INTERRUPT);
  806. begin
  807.   DeviceIOControl(hWD, IOCTL_WD_INT_ENABLE, @TheInterrupt,
  808.                   SizeOf(WD_INTERRUPT), nil, 0, WinDriverGlobalDW, nil)
  809. end;
  810.  
  811. procedure WD_IntDisable(hWD: HANDLE ;var TheInterrupt: WD_INTERRUPT);
  812. begin
  813.   DeviceIOControl(hWD, IOCTL_WD_INT_DISABLE, @TheInterrupt,
  814.                   SizeOf(WD_INTERRUPT), nil, 0, WinDriverGlobalDW, nil)
  815. end;
  816.  
  817. procedure WD_IntCount(hWD: HANDLE ;var TheInterrupt: WD_INTERRUPT);
  818. begin
  819.   DeviceIOControl(hWD, IOCTL_WD_INT_COUNT, @TheInterrupt,
  820.                   SizeOf(WD_INTERRUPT), nil, 0, WinDriverGlobalDW, nil)
  821. end;
  822.  
  823. procedure WD_IntWait(hWD: HANDLE ;var TheInterrupt: WD_INTERRUPT);
  824. var
  825.   h: HANDLE;
  826. begin
  827.   h:=WD_Open();
  828.   DeviceIOControl(h, IOCTL_WD_INT_WAIT, @TheInterrupt,
  829.                   SizeOf(WD_INTERRUPT), nil, 0, WinDriverGlobalDW, nil);
  830.   WD_Close(h);
  831. end;
  832.  
  833. procedure WD_IsapnpScanCards(hWD: HANDLE ;var IsapnpScanCards: WD_ISAPNP_SCAN_CARDS);
  834. begin
  835.   DeviceIOControl(hWD, IOCTL_WD_ISAPNP_SCAN_CARDS, @IsapnpScanCards,
  836.                   SizeOf(WD_ISAPNP_SCAN_CARDS), nil, 0, WinDriverGlobalDW, nil)
  837. end;
  838.  
  839. procedure WD_IsapnpGetCardInfo(hWD: HANDLE ;var IsapnpGetCardInfo: WD_ISAPNP_CARD_INFO);
  840. begin
  841.   DeviceIOControl(hWD, IOCTL_WD_ISAPNP_GET_CARD_INFO, @IsapnpGetCardInfo,
  842.                   SizeOf(WD_ISAPNP_CARD_INFO), nil, 0, WinDriverGlobalDW, nil)
  843. end;
  844.  
  845. procedure WD_IsapnpConfigDump(hWD: HANDLE ;var IsapnpConfigDump: WD_ISAPNP_CONFIG_DUMP);
  846. begin
  847.   DeviceIOControl(hWD, IOCTL_WD_ISAPNP_CONFIG_DUMP, @IsapnpConfigDump,
  848.                   SizeOf(WD_ISAPNP_CONFIG_DUMP), nil, 0, WinDriverGlobalDW, nil)
  849. end;
  850.  
  851. procedure WD_PcmciaScanCards(hWD: HANDLE ;var PcmciaScanCards: WD_PCMCIA_SCAN_CARDS);
  852. begin
  853.   DeviceIOControl(hWD, IOCTL_WD_PCMCIA_SCAN_CARDS, @PcmciaScanCards,
  854.                   SizeOf(WD_PCMCIA_SCAN_CARDS), nil, 0, WinDriverGlobalDW, nil)
  855. end;
  856.  
  857. procedure WD_PcmciaGetCardInfo(hWD: HANDLE ;var PcmciaGetCardInfo: WD_PCMCIA_CARD_INFO);
  858. begin
  859.   DeviceIOControl(hWD, IOCTL_WD_PCMCIA_GET_CARD_INFO, @PcmciaGetCardInfo,
  860.                   SizeOf(WD_PCMCIA_CARD_INFO), nil, 0, WinDriverGlobalDW, nil)
  861. end;
  862.  
  863. procedure WD_PcmciaConfigDump(hWD: HANDLE ;var PcmciaConfigDump: WD_PCMCIA_CONFIG_DUMP);
  864. begin
  865.   DeviceIOControl(hWD, IOCTL_WD_PCMCIA_CONFIG_DUMP, @PcmciaConfigDump,
  866.                   SizeOf(WD_PCMCIA_CONFIG_DUMP), nil, 0, WinDriverGlobalDW, nil)
  867. end;
  868.  
  869. procedure WD_Sleep(hWD: HANDLE ;var Sleep: SWD_SLEEP);
  870. begin
  871.   DeviceIOControl(hWD, IOCTL_WD_SLEEP, @Sleep,
  872.                   SizeOf(SWD_SLEEP), nil, 0, WinDriverGlobalDW, nil)
  873. end;
  874.  
  875. procedure WD_CardRegister(hWD: HANDLE ;var Card: WD_CARD_REGISTER);
  876. begin
  877.   DeviceIOControl(hWD, IOCTL_WD_CARD_REGISTER, @Card,
  878.                   SizeOf(WD_CARD_REGISTER), nil, 0, WinDriverGlobalDW, nil)
  879. end;
  880.  
  881. procedure WD_CardUnregister(hWD: HANDLE ;var Card: WD_CARD_REGISTER);
  882. begin
  883.   DeviceIOControl(hWD, IOCTL_WD_CARD_UNREGISTER, @Card,
  884.                   SizeOf(WD_CARD_REGISTER), nil, 0, WinDriverGlobalDW, nil)
  885. end;
  886.  
  887. procedure WD_PciScanCards(hWD: HANDLE ;var PciScan: WD_PCI_SCAN_CARDS);
  888. begin
  889.   DeviceIOControl(hWD, IOCTL_WD_PCI_SCAN_CARDS, @PciScan,
  890.                   SizeOf(WD_PCI_SCAN_CARDS), nil, 0, WinDriverGlobalDW, nil)
  891. end;
  892.  
  893. procedure WD_PciGetCardInfo(hWD: HANDLE ;var PciCard: WD_PCI_CARD_INFO);
  894. begin
  895.   DeviceIOControl(hWD, IOCTL_WD_PCI_GET_CARD_INFO, @PciCard,
  896.                   SizeOf(WD_PCI_CARD_INFO), nil, 0, WinDriverGlobalDW, nil)
  897. end;
  898.  
  899. procedure WD_Version(hWD: HANDLE ;var VerInfo: SWD_VERSION);
  900. begin
  901.   DeviceIOControl(hWD, IOCTL_WD_VERSION, @VerInfo, SizeOf(SWD_VERSION),
  902.                   nil, 0, WinDriverGlobalDW, nil)
  903. end;
  904.  
  905. procedure WD_License(hWD: HANDLE ;var License: SWD_LICENSE);
  906. begin
  907.   DeviceIOControl(hWD, IOCTL_WD_LICENSE, @License, SizeOf(SWD_LICENSE),
  908.                   nil, 0, WinDriverGlobalDW, nil)
  909. end;
  910.  
  911. procedure WD_KernelPlugInOpen(hWD: HANDLE ;var KernelPlugInOpen: WD_KERNEL_PLUGIN);
  912. begin
  913.   DeviceIOControl(hWD, IOCTL_WD_KERNEL_PLUGIN_OPEN, @KernelPlugInOpen, SizeOf(WD_KERNEL_PLUGIN),
  914.                   nil, 0, WinDriverGlobalDW, nil)
  915. end;
  916.  
  917. procedure WD_KernelPlugInClose(hWD: HANDLE ;var KernelPlugInClose: WD_KERNEL_PLUGIN);
  918. begin
  919.   DeviceIOControl(hWD, IOCTL_WD_KERNEL_PLUGIN_CLOSE, @KernelPlugInClose, SizeOf(WD_KERNEL_PLUGIN),
  920.                   nil, 0, WinDriverGlobalDW, nil)
  921. end;
  922.  
  923. procedure WD_KernelPlugInCall(hWD: HANDLE ;var KernelPlugInCall: WD_KERNEL_PLUGIN_CALL);
  924. begin
  925.   DeviceIOControl(hWD, IOCTL_WD_KERNEL_PLUGIN_CALL, @KernelPlugInCall, SizeOf(WD_KERNEL_PLUGIN_CALL),
  926.                   nil, 0, WinDriverGlobalDW, nil)
  927. end;
  928.  
  929. procedure WD_PciConfigDump(hWD: HANDLE ;var PciConfigDump: WD_PCI_CONFIG_DUMP);
  930. begin
  931.   DeviceIOControl(hWD, IOCTL_WD_PCI_CONFIG_DUMP, @PciConfigDump,
  932.                   SizeOf(WD_PCI_CONFIG_DUMP), nil, 0, WinDriverGlobalDW, nil)
  933. end;
  934.  
  935. procedure WD_FUNCTION(wFuncNum : DWORD; h : HANDLE; pParam : POINTER; dwSize : DWORD);
  936. begin
  937.     DeviceIoControl(h, wFuncNum, pParam, dwSize, nil, 0, WinDriverGlobalDW, nil);
  938. end;
  939.  
  940.  
  941. procedure WD_UsbScanDevice(h : HANDLE; pDeviceId : PWD_USB_ID);
  942. begin
  943.     WD_FUNCTION(IOCTL_WD_USB_SCAN_DEVICES, h, POINTER(pDeviceId), DWORD(SizeOf(WD_USB_SCAN_DEVICES)));
  944. end;
  945.  
  946.  
  947. procedure WD_UsbGetConfiguration(h : HANDLE; pDeviceId : PWD_USB_ID);
  948. begin
  949.     WD_FUNCTION(IOCTL_WD_USB_GET_CONFIGURATION, h, POINTER(pDeviceId), DWORD(SizeOf(WD_USB_CONFIGURATION)));
  950. end;
  951.  
  952.  
  953. procedure WD_UsbDeviceRegister(h : HANDLE; pRegister : PWD_USB_DEVICE_REGISTER);
  954. begin
  955.     WD_FUNCTION(IOCTL_WD_USB_DEVICE_REGISTER, h, pRegister, DWORD(sizeof(WD_USB_DEVICE_REGISTER)));
  956. end;
  957.  
  958.  
  959. procedure WD_UsbTransfer(h : HANDLE; pTrans : PWD_USB_TRANSFER);
  960. var
  961.   lh: HANDLE;
  962. begin
  963.     lh:=WD_Open();
  964.     WD_FUNCTION(IOCTL_WD_USB_TRANSFER, lh, POINTER(pTrans), DWORD(SizeOf(WD_USB_TRANSFER)));
  965.     WD_Close(lh);
  966. end;
  967.  
  968.  
  969. procedure WD_UsbDeviceUnregister(h : HANDLE; pTrans : PWD_USB_DEVICE_REGISTER);
  970. begin
  971.     WD_FUNCTION(IOCTL_WD_USB_DEVICE_UNREGISTER, h, POINTER(pTrans), DWORD(SizeOf(WD_USB_DEVICE_REGISTER)));
  972. end;
  973.  
  974.  
  975. procedure WD_UsbResetPipe(h : HANDLE; pResetPipe : PWD_USB_RESET_PIPE);
  976. begin
  977.     WD_FUNCTION(IOCTL_WD_USB_RESET_PIPE, h, POINTER(pResetPipe), DWORD(SizeOf(WD_USB_RESET_PIPE)));
  978. end;
  979.  
  980.  
  981. procedure WD_UsbResetDevice(h : HANDLE; hDevice : DWORD);
  982. begin
  983.     WD_FUNCTION(IOCTL_WD_USB_RESET_DEVICE, h, @hDevice, DWORD(SizeOf(DWORD)));
  984. end;
  985.  
  986. initialization
  987.     IOCTL_WD_DMA_LOCK               := Get_Ctl_Code($901) ;
  988.     IOCTL_WD_DMA_UNLOCK             := Get_Ctl_Code($902) ;
  989.     IOCTL_WD_TRANSFER               := Get_Ctl_Code($903) ;
  990.     IOCTL_WD_MULTI_TRANSFER         := Get_Ctl_Code($904) ;
  991.     IOCTL_WD_PCI_SCAN_CARDS         := Get_Ctl_Code($90e) ;
  992.     IOCTL_WD_PCI_GET_CARD_INFO      := Get_Ctl_Code($90f) ;
  993.     IOCTL_WD_VERSION                := Get_Ctl_Code($910) ;
  994.     IOCTL_WD_PCI_CONFIG_DUMP        := Get_Ctl_Code($91a) ;
  995.     IOCTL_WD_KERNEL_PLUGIN_OPEN     := Get_Ctl_Code($91b) ;
  996.     IOCTL_WD_KERNEL_PLUGIN_CLOSE    := Get_Ctl_Code($91c) ;
  997.     IOCTL_WD_KERNEL_PLUGIN_CALL     := Get_Ctl_Code($91d) ;
  998.     IOCTL_WD_INT_ENABLE             := Get_Ctl_Code($91e) ;
  999.     IOCTL_WD_INT_DISABLE            := Get_Ctl_Code($91f) ;
  1000.     IOCTL_WD_INT_COUNT              := Get_Ctl_Code($920) ;
  1001.     IOCTL_WD_ISAPNP_SCAN_CARDS      := Get_Ctl_Code($924) ;
  1002.     IOCTL_WD_ISAPNP_CONFIG_DUMP     := Get_Ctl_Code($926) ;
  1003.     IOCTL_WD_SLEEP                  := Get_Ctl_Code($927) ;
  1004.     IOCTL_WD_DEBUG                  := Get_Ctl_Code($928) ;
  1005.     IOCTL_WD_DEBUG_DUMP             := Get_Ctl_Code($929) ;
  1006.     IOCTL_WD_CARD_UNREGISTER        := Get_Ctl_Code($92b) ;
  1007.     IOCTL_WD_ISAPNP_GET_CARD_INFO   := Get_Ctl_Code($92d) ;
  1008.     IOCTL_WD_PCMCIA_SCAN_CARDS      := Get_Ctl_Code($92f) ;
  1009.     IOCTL_WD_PCMCIA_GET_CARD_INFO   := Get_Ctl_Code($930) ;
  1010.     IOCTL_WD_PCMCIA_CONFIG_DUMP     := Get_Ctl_Code($931) ;
  1011.     IOCTL_WD_CARD_REGISTER          := Get_Ctl_Code($956) ;
  1012.     IOCTL_WD_INT_WAIT               := Get_Ctl_Code($94b) ;
  1013.     IOCTL_WD_LICENSE                := Get_Ctl_Code($952) ;
  1014.     IOCTL_WD_USB_RESET_PIPE         := Get_Ctl_Code($93c) ;
  1015.     IOCTL_WD_USB_RESET_DEVICE       := Get_Ctl_Code($93f) ;
  1016.     IOCTL_WD_USB_SCAN_DEVICES_V432  := Get_Ctl_Code($940) ;
  1017.     IOCTL_WD_USB_SCAN_DEVICES       := Get_Ctl_Code($95a) ;
  1018.     IOCTL_WD_USB_TRANSFER           := Get_Ctl_Code($942) ;
  1019.     IOCTL_WD_USB_DEVICE_REGISTER    := Get_Ctl_Code($949) ;
  1020.     IOCTL_WD_USB_DEVICE_UNREGISTER  := Get_Ctl_Code($959) ;
  1021.     IOCTL_WD_USB_GET_CONFIGURATION  := Get_Ctl_Code($946) ;
  1022.  
  1023. end.
  1024.  
  1025.